home *** CD-ROM | disk | FTP | other *** search
/ PC Graphics Unleashed / PC Graphics Unleashed.iso / ch18 / rad386 / radiosit / src / for_radi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-21  |  3.8 KB  |  174 lines
  1. /* Copyright (c) 1991 Regents of the University of California */
  2.  
  3. #ifndef lint
  4. static char SCCSid[] = "@(#)color.c 2.1 11/12/91 LBL";
  5. #endif
  6.  
  7. /*
  8.  *  color.c - routines for color calculations.
  9.  *
  10.  *     10/10/85
  11.  */
  12.  
  13. #include  <stdio.h>
  14.  
  15. #include  "color.h"
  16.  
  17. #define  MINELEN    8    /* minimum scanline length for encoding */
  18. #define  MINRUN        4    /* minimum run length */
  19.  
  20.  
  21. char *tempbuffer(len)            /* get a temporary buffer */
  22. unsigned  len;
  23. {
  24.     extern char  *malloc(), *realloc();
  25.     static char  *tempbuf = NULL;
  26.     static int  tempbuflen = 0;
  27.  
  28.     if (len > tempbuflen) {
  29.         if (tempbuflen > 0)
  30.             tempbuf = realloc(tempbuf, len);
  31.         else
  32.             tempbuf = malloc(len);
  33.         tempbuflen = tempbuf==NULL ? 0 : len;
  34.     }
  35.     return(tempbuf);
  36. }
  37.  
  38.  
  39. int fwritecolrs(scanline, len, fp)        /* write out a colr scanline */
  40. register COLR  *scanline;
  41. int  len;
  42. register FILE  *fp;
  43. {
  44.     register int  i, j, beg, cnt;
  45.     int  c2;
  46.     
  47.     if (len < MINELEN)        /* too small to encode */
  48.         return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
  49.     if (len > 32767)        /* too big! */
  50.         return(-1);
  51.     putc(2, fp);            /* put magic header */
  52.     putc(2, fp);
  53.     putc(len>>8, fp);
  54.     putc(len&255, fp);
  55.                     /* put components seperately */
  56.     for (i = 0; i < 4; i++) {
  57.         for (j = 0; j < len; j += cnt) {    /* find next run */
  58.         for (beg = j; beg < len; beg += cnt) {
  59.             for (cnt = 1; cnt < 127 && beg+cnt < len &&
  60.                 scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
  61.             ;
  62.             if (cnt >= MINRUN)
  63.             break;            /* long enough */
  64.         }
  65.         if (beg-j > 1 && beg-j < MINRUN) {
  66.             c2 = j+1;
  67.             while (scanline[c2++][i] == scanline[j][i])
  68.             if (c2 == beg) {    /* short run */
  69.                 putc(128+beg-j, fp);
  70.                 putc(scanline[j][i], fp);
  71.                 j = beg;
  72.                 break;
  73.             }
  74.         }
  75.         while (j < beg) {        /* write out non-run */
  76.             if ((c2 = beg-j) > 128) c2 = 128;
  77.             putc(c2, fp);
  78.             while (c2--)
  79.             putc(scanline[j++][i], fp);
  80.         }
  81.         if (cnt >= MINRUN) {        /* write out run */
  82.             putc(128+cnt, fp);
  83.             putc(scanline[beg][i], fp);
  84.         } else
  85.             cnt = 0;
  86.         }
  87.     }
  88.     return(ferror(fp) ? -1 : 0);
  89. }
  90.  
  91. int fwritescan(scanline, len, fp)        /* write out a scanline */
  92. register COLOR  *scanline;
  93. int  len;
  94. FILE  *fp;
  95. {
  96.     COLR  *clrscan;
  97.     int  n;
  98.     register COLR  *sp;
  99.                     /* get scanline buffer */
  100.     if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
  101.         return(-1);
  102.     clrscan = sp;
  103.                     /* convert scanline */
  104.     n = len;
  105.     while (n-- > 0) {
  106.         setcolr(sp[0], scanline[0][RED],
  107.                   scanline[0][GRN],
  108.                   scanline[0][BLU]);
  109.         scanline++;
  110.         sp++;
  111.     }
  112.     return(fwritecolrs(clrscan, len, fp));
  113. }
  114.  
  115. int setcolr(clr, r, g, b)        /* assign a short color value */
  116. register COLR  clr;
  117. double  r, g, b;
  118. {
  119.     double  frexp();
  120.     double  d;
  121.     int  e;
  122.     
  123.     d = r > g ? r : g;
  124.     if (b > d) d = b;
  125.  
  126.     if (d <= 1e-32) {
  127.         clr[RED] = clr[GRN] = clr[BLU] = 0;
  128.         clr[EXP] = 0;
  129.         return;
  130.     }
  131.  
  132.     d = frexp(d, &e) * 256.0 / d;
  133.  
  134.     clr[RED] = r * d;
  135.     clr[GRN] = g * d;
  136.     clr[BLU] = b * d;
  137.     clr[EXP] = e + COLXS;
  138. }
  139. /* Copyright (c) 1991 Regents of the University of California */
  140.  
  141. /*
  142.  *  header.c - routines for reading and writing information headers.
  143.  *
  144.  *    8/19/88
  145.  *
  146.  *  printargs(ac,av,fp)    print an argument list to fp, followed by '\n'
  147.  *  isformat(s)        returns true if s is of the form "FORMAT=*"
  148.  *  formatval(r,s)    copy the format value in s to r
  149.  *  fputformat(s,fp)    write "FORMAT=%s" to fp
  150.  *  getheader(fp,f,p)    read header from fp, calling f(s,p) on each line
  151.  *  checkheader(i,p,o)    check header format from i against p and copy to o
  152.  *
  153.  *  To copy header from input to output, use getheader(fin, fputs, fout)
  154.  */
  155.  
  156. #include  <stdio.h>
  157. #include  <ctype.h>
  158.  
  159. #define  MAXLINE    512
  160.  
  161. char  FMTSTR[] = "FORMAT=";
  162. int  FMTSTRL = 7;
  163.  
  164.  
  165. int fputformat(s, fp)        /* put out a format value */
  166. char  *s;
  167. FILE  *fp;
  168. {
  169.     fputs(FMTSTR, fp);
  170.     fputs(s, fp);
  171.     putc('\n', fp);
  172. }
  173.  
  174.